package com.example.demo.service.impl;

import com.example.demo.entity.GoodsSkus;
import com.example.demo.entity.GoodsSkusValue;
import com.example.demo.exception.BusinessException;
import com.example.demo.exception.ErrorCode;
import com.example.demo.mapper.GoodsSkusMapper;
import com.example.demo.mapper.GoodsSkusValueMapper;
import com.example.demo.service.GoodsSkusService;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class GoodsSkusServiceImpl implements GoodsSkusService {

    private static final Logger logger = LoggerFactory.getLogger(GoodsSkusServiceImpl.class);

    @Autowired
    private GoodsSkusMapper goodsSkusMapper;

    @Autowired
    private GoodsSkusValueMapper goodsSkusValueMapper;

    @Override
    public GoodsSkus createGoodsSkus(GoodsSkus goodsSkus) {
        goodsSkusMapper.insert(goodsSkus);
        logger.info("创建商品规格信息: {}", goodsSkus);
        return goodsSkus;
    }

    @Override
    public boolean updateGoodsSkus(GoodsSkus goodsSkus) {
        List<GoodsSkus> gSkusList = goodsSkusMapper.selectById(goodsSkus.getId());
        if (gSkusList.size() == 0) {
            throw new BusinessException(ErrorCode.GOODS_SKUS_NOT_FOUND);
        }
        goodsSkusMapper.updateById(goodsSkus);
        logger.info("更新商品规格信息: {}", goodsSkus);
        return true;
    }

    @Override
    public boolean deleteGoodsSkus(Integer id) {
        List<GoodsSkus> gSkusList = goodsSkusMapper.selectById(id);
        if (gSkusList.size() == 0) {
            throw new BusinessException(ErrorCode.GOODS_SKUS_NOT_FOUND);
        }
        goodsSkusMapper.deleteById(id);
        logger.info("删除商品规格信息: {}", id);
        return true;
    }

    @Override
    public List<GoodsSkus> getGoodsSkusByGoodsId(Integer goods_id) {
        return goodsSkusMapper.selectByGoodsId(goods_id);
    }

    @Override
    public List<GoodsSkus> getGoodsSkusWithValuesByGoodsId(Integer goodsId) {
        List<GoodsSkus> goodsSkusList = goodsSkusMapper.selectByGoodsId(goodsId);

        for (GoodsSkus goodsSkus : goodsSkusList) {
            List<GoodsSkusValue> goodsSkusValues = goodsSkusValueMapper.selectBySkuId(goodsSkus.getId());
            goodsSkus.setGoodsSkusValues(goodsSkusValues);
        }

        return goodsSkusList;
    }

    @Override
    public boolean updateGoodsSkusOrder(List<GoodsSkus> goodsSkusList) {
        for (GoodsSkus goodsSkus : goodsSkusList) {
            goodsSkusMapper.updateOrderById(goodsSkus.getId(), goodsSkus.getOrder());
        }
        return true;
    }

    @Override
    public GoodsSkusValue createGoodsSkusValue(GoodsSkusValue goodsSkusValue) {
        goodsSkusValueMapper.insert(goodsSkusValue);
        return goodsSkusValue;
    }

    @Override
    public boolean updateGoodsSkusValue(GoodsSkusValue goodsSkusValue) {
        return goodsSkusValueMapper.updateById(goodsSkusValue) > 0;
    }

    @Override
    public boolean deleteGoodsSkusValue(Integer id) {
        return goodsSkusValueMapper.deleteById(id) > 0;
    }

    @Override
    public List<GoodsSkusValue> getGoodsSkusValueBySkuId(Integer sku_id) {
        return goodsSkusValueMapper.selectBySkuId(sku_id);
    }

    @Override
    @Transactional
    public Map<String, Object> setGoodsSkusAndValues(Integer skuId, Integer goodsId, String name, List<String> values) {
        // 先查询是否已经存在该规格
        List<GoodsSkus> list = goodsSkusMapper.selectById(skuId);
        GoodsSkus goodsSkus = list.get(0);

        if (goodsSkus == null) {
            goodsSkus = new GoodsSkus();
            goodsSkus.setOrder(50);
        }
        goodsSkus.setGoods_id(goodsId);
        goodsSkus.setName(name);
        
        if(goodsSkus.getId() == null) {
            goodsSkusMapper.insert(goodsSkus);
        } else {
            goodsSkusMapper.updateById(goodsSkus);
        }
        

        // 获取当前规格下的所有规格值
        List<GoodsSkusValue> existingValues = goodsSkusValueMapper.selectBySkuId(goodsSkus.getId());
        // 存储需要删除的规格值 ID
        List<Integer> toDeleteIds = new ArrayList<>();
        // 存储需要新增的规格值
        List<String> toAddValues = new ArrayList<>(values);
        // 遍历现有规格值，判断是否需要删除
        for (GoodsSkusValue existingValue : existingValues) {
            if (values.contains(existingValue.getValue())) {
                // 如果传入的数组中包含该规格值，则从待新增列表中移除
                toAddValues.remove(existingValue.getValue());
            } else {
                // 如果传入的数组中不包含该规格值，则标记为待删除
                toDeleteIds.add(existingValue.getId());
            }
        }
        // 删除不需要的规格值
        for (Integer id : toDeleteIds) {
            goodsSkusValueMapper.deleteById(id);
        }
        // 新增缺失的规格值
        for (String value : toAddValues) {
            GoodsSkusValue skusValue = new GoodsSkusValue();
            skusValue.setSku_id(goodsSkus.getId());
            skusValue.setValue(value);
            goodsSkusValueMapper.insert(skusValue);
        }
        // 重新获取最新的规格值列表
        List<GoodsSkusValue> updatedValues = goodsSkusValueMapper.selectBySkuId(goodsSkus.getId());
        Map<String, Object> result = new HashMap<>();
        Map<String, Object> skusMap = new HashMap<>();
        skusMap.put("id", goodsSkus.getId());
        skusMap.put("name", goodsSkus.getName());
        result.put("goods_skus", skusMap);
        List<Map<String, Object>> valuesList = new ArrayList<>();
        for (GoodsSkusValue skusValue : updatedValues) {
            Map<String, Object> valueMap = new HashMap<>();
            valueMap.put("id", skusValue.getId());
            valueMap.put("skus_id", skusValue.getSku_id());
            valueMap.put("value", skusValue.getValue());
            valuesList.add(valueMap);
        }
        result.put("goods_skus_value", valuesList);
        return result;
    }
}
